﻿
namespace iopt.solvency.pillarone.client.Web.Services
{
    using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.ComponentModel.DataAnnotations;
    using System.Data;
    using System.Linq;
    using System.ServiceModel.DomainServices.EntityFramework;
    using System.ServiceModel.DomainServices.Hosting;
    using System.ServiceModel.DomainServices.Server;
    using iopt.solvency.pillarone.client.Web;


    // Implémente la logique d'application à l'aide du contexte DatabaseModelContainer.
    // TODO: ajoutez votre logique d'application à ces méthodes ou dans d'autres méthodes.
    // TODO: connectez l'authentification (Windows/ASP.NET Forms) et supprimez les marques de commentaire suivantes pour désactiver l'accès anonyme
    // Ajoutez également des rôles pour limiter l'accès, selon le cas.
    // [RequiresAuthentication]
    [EnableClientAccess()]
    public class CoreDomainService : LinqToEntitiesDomainService<DatabaseModelContainer>
    {

        // TODO:
        // appliquez une contrainte aux résultats de votre méthode query. Si vous avez besoin d'une entrée supplémentaire, vous pouvez
        // ajouter des paramètres à cette méthode ou créer d'autres méthodes query avec des noms différents.
        // Pour prendre en charge la pagination, vous devez ajouter un classement à la requête « EntityDefinitionJeu ».
        [Query(IsDefault = true)]
        public IQueryable<EntityDefinition> GetEntityDefinitionJeu()
        {
            return this.ObjectContext.EntityDefinitionJeu;
        }

        public void InsertEntityDefinition(EntityDefinition entityDefinition)
        {
            if ((entityDefinition.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(entityDefinition, EntityState.Added);
            }
            else
            {
                this.ObjectContext.EntityDefinitionJeu.AddObject(entityDefinition);
            }
        }

        public void UpdateEntityDefinition(EntityDefinition currentEntityDefinition)
        {
            this.ObjectContext.EntityDefinitionJeu.AttachAsModified(currentEntityDefinition, this.ChangeSet.GetOriginal(currentEntityDefinition));
        }

        public void DeleteEntityDefinition(EntityDefinition entityDefinition)
        {
            if ((entityDefinition.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(entityDefinition, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.EntityDefinitionJeu.Attach(entityDefinition);
                this.ObjectContext.EntityDefinitionJeu.DeleteObject(entityDefinition);
            }
        }

        // TODO:
        // appliquez une contrainte aux résultats de votre méthode query. Si vous avez besoin d'une entrée supplémentaire, vous pouvez
        // ajouter des paramètres à cette méthode ou créer d'autres méthodes query avec des noms différents.
        // Pour prendre en charge la pagination, vous devez ajouter un classement à la requête « ModelDefinitionJeu ».
        [Query(IsDefault = true)]
        public IQueryable<ModelDefinition> GetModelDefinitionJeu()
        {
            return this.ObjectContext.ModelDefinitionJeu;
        }

        public void InsertModelDefinition(ModelDefinition modelDefinition)
        {
            if ((modelDefinition.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(modelDefinition, EntityState.Added);
            }
            else
            {
                this.ObjectContext.ModelDefinitionJeu.AddObject(modelDefinition);
            }
        }

        public void UpdateModelDefinition(ModelDefinition currentModelDefinition)
        {
            this.ObjectContext.ModelDefinitionJeu.AttachAsModified(currentModelDefinition, this.ChangeSet.GetOriginal(currentModelDefinition));
        }

        public void DeleteModelDefinition(ModelDefinition modelDefinition)
        {
            if ((modelDefinition.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(modelDefinition, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.ModelDefinitionJeu.Attach(modelDefinition);
                this.ObjectContext.ModelDefinitionJeu.DeleteObject(modelDefinition);
            }
        }

        // TODO:
        // appliquez une contrainte aux résultats de votre méthode query. Si vous avez besoin d'une entrée supplémentaire, vous pouvez
        // ajouter des paramètres à cette méthode ou créer d'autres méthodes query avec des noms différents.
        // Pour prendre en charge la pagination, vous devez ajouter un classement à la requête « ModelFieldDefinitionJeu ».
        [Query(IsDefault = true)]
        public IQueryable<ModelFieldDefinition> GetModelFieldDefinitionJeu()
        {
            return this.ObjectContext.ModelFieldDefinitionJeu;
        }

        public void InsertModelFieldDefinition(ModelFieldDefinition modelFieldDefinition)
        {
            if ((modelFieldDefinition.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(modelFieldDefinition, EntityState.Added);
            }
            else
            {
                this.ObjectContext.ModelFieldDefinitionJeu.AddObject(modelFieldDefinition);
            }
        }

        public void UpdateModelFieldDefinition(ModelFieldDefinition currentModelFieldDefinition)
        {
            this.ObjectContext.ModelFieldDefinitionJeu.AttachAsModified(currentModelFieldDefinition, this.ChangeSet.GetOriginal(currentModelFieldDefinition));
        }

        public void DeleteModelFieldDefinition(ModelFieldDefinition modelFieldDefinition)
        {
            if ((modelFieldDefinition.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(modelFieldDefinition, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.ModelFieldDefinitionJeu.Attach(modelFieldDefinition);
                this.ObjectContext.ModelFieldDefinitionJeu.DeleteObject(modelFieldDefinition);
            }
        }

        // TODO:
        // appliquez une contrainte aux résultats de votre méthode query. Si vous avez besoin d'une entrée supplémentaire, vous pouvez
        // ajouter des paramètres à cette méthode ou créer d'autres méthodes query avec des noms différents.
        // Pour prendre en charge la pagination, vous devez ajouter un classement à la requête « ProjectJeu ».
        [Query(IsDefault = true)]
        public IQueryable<Project> GetProjectJeu()
        {
            return this.ObjectContext.ProjectJeu;
        }

        public void InsertProject(Project project)
        {
            if ((project.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(project, EntityState.Added);
            }
            else
            {
                this.ObjectContext.ProjectJeu.AddObject(project);
            }
        }

        public void UpdateProject(Project currentProject)
        {
            this.ObjectContext.ProjectJeu.AttachAsModified(currentProject, this.ChangeSet.GetOriginal(currentProject));
        }

        public void DeleteProject(Project project)
        {
            if ((project.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(project, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.ProjectJeu.Attach(project);
                this.ObjectContext.ProjectJeu.DeleteObject(project);
            }
        }

        // TODO:
        // appliquez une contrainte aux résultats de votre méthode query. Si vous avez besoin d'une entrée supplémentaire, vous pouvez
        // ajouter des paramètres à cette méthode ou créer d'autres méthodes query avec des noms différents.
        // Pour prendre en charge la pagination, vous devez ajouter un classement à la requête « TypeDefinitionJeu ».
        [Query(IsDefault = true)]
        public IQueryable<TypeDefinition> GetTypeDefinitionJeu()
        {
            return this.ObjectContext.TypeDefinitionJeu;
        }

        public void InsertTypeDefinition(TypeDefinition typeDefinition)
        {
            if ((typeDefinition.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(typeDefinition, EntityState.Added);
            }
            else
            {
                this.ObjectContext.TypeDefinitionJeu.AddObject(typeDefinition);
            }
        }

        public void UpdateTypeDefinition(TypeDefinition currentTypeDefinition)
        {
            this.ObjectContext.TypeDefinitionJeu.AttachAsModified(currentTypeDefinition, this.ChangeSet.GetOriginal(currentTypeDefinition));
        }

        public void DeleteTypeDefinition(TypeDefinition typeDefinition)
        {
            if ((typeDefinition.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(typeDefinition, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.TypeDefinitionJeu.Attach(typeDefinition);
                this.ObjectContext.TypeDefinitionJeu.DeleteObject(typeDefinition);
            }
        }

        // TODO:
        // appliquez une contrainte aux résultats de votre méthode query. Si vous avez besoin d'une entrée supplémentaire, vous pouvez
        // ajouter des paramètres à cette méthode ou créer d'autres méthodes query avec des noms différents.
        // Pour prendre en charge la pagination, vous devez ajouter un classement à la requête « WorkspaceJeu ».
        [Query(IsDefault = true)]
        public IQueryable<Workspace> GetWorkspaceJeu()
        {
            return this.ObjectContext.WorkspaceJeu;
        }

        public void InsertWorkspace(Workspace workspace)
        {
            if ((workspace.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(workspace, EntityState.Added);
            }
            else
            {
                this.ObjectContext.WorkspaceJeu.AddObject(workspace);
            }
        }

        public void UpdateWorkspace(Workspace currentWorkspace)
        {
            this.ObjectContext.WorkspaceJeu.AttachAsModified(currentWorkspace, this.ChangeSet.GetOriginal(currentWorkspace));
        }

        public void DeleteWorkspace(Workspace workspace)
        {
            if ((workspace.EntityState != EntityState.Detached))
            {
                this.ObjectContext.ObjectStateManager.ChangeObjectState(workspace, EntityState.Deleted);
            }
            else
            {
                this.ObjectContext.WorkspaceJeu.Attach(workspace);
                this.ObjectContext.WorkspaceJeu.DeleteObject(workspace);
            }
        }
    }
}


